#1,实现1-100的和

#方法一
def f1():
    sum=0
    for i in range (1,101):
        sum = sum + i
    print(sum)
#f1()
#方法二
def sum():
    sum = 0
    for n in range(1, 101):
        sum = sum + n
    print(sum)
#sum()

#方法三
def sum(x, y):
    return x + y
from functools import reduce
#print(reduce(sum, range(1,101)))

#f方法四
def sum():
    sum = 0
    x = 1
    while x < 101:
        sum = sum + x
        x += 1
    print(sum)
#sum()

#方法五
def sum(start, end):
    sum = 0
    for n in range(start, end + 1, 1):
        sum = sum + n
    print(sum)
#sum(1, 100)

#方法六
def sum():
    from functools import reduce
    print(reduce(lambda x, y: x+y, range(1,101)))

#sum()

#2,列表去重并从大到小排序

#列表去重
#1，转换为集合再转换为列表
#2，循环遍历去除重复项后在写入
#3，使用字典的方式

#方法1
def f1():
    list1=list(set([1,1,2,8,4,7,7]))
    list1.sort(reverse = True)
    print(list1)
#f1()

#方法2
def f1(list2):
    list1 = []
    for i in list2:
        if i not in list1:
            list1.append(i)
    print(list1)
#f1([1,1,2,8,4,7,7])
#方法3
def f1(list3):
    list3.sort(reverse = True)
    print({}.fromkeys(list3).keys())
#f1([1,1,2,8,4,7,7])

#3,如何在一个函数内部修改全局变量

global_var = "good"
def f2():
    global global_var
    global_var = "night"
    print(global_var)
#f2()
#print(global_var)

#4,如何跨模块共享全局变量
'''
from test import num   
num.async = "4"   #在two.py中定义了autho这个变量
print(num.async)
'''
#5,python 数据类型有哪些
def f3():
    #1,整型
    print(type(1))
    #2,字符型
    print(type('r'))
    #3,浮点型
    print(type(0.45))
    #4，列表
    print(type([1,2]))
    #5,集合
    print(type({1,2,3}))
    #6，元组
    print(type((1,2)))
    #7,字典
    print(type({'name':1,'age':2}))
    #8,布尔
    print(type(True))
    #9,复数
    print(type(1+2j))
#f3()

# 6,生成随机整数（1-10）随机小数（1-10）生成0-1之间的小数
def f4():

    import random
    a = random.randint(1,10)  #生成1-10之间的随机整数
    b = random.uniform(1,10)  #生成1-10之间的小数
    c = random.random()    #生成0-1之间的小数

    print(a)
    print(b)
    print(c)
#f4()

#7，python2与python3的区别，列出5个
'''
1，市场差异
python2：官方通知python2 2020开始不再维护，但企业很多代码都是python2,python2有很大的用户基群故会出现历史遗留问题，
需要很长时间的迁移过度到python3
python3：最新版本，但目前市场使用量不大
2，系统差异
python2：是centos 6-7系统默认支持的python版本
python3：是centos8系统默认支持的python版本
3，输出差异（代码举例）
python2：

>>> print "abc"
abc
>>> print("abc")
abc

python3：

>>> print "abc"
 会报错
>>> print("abc")
abc

4，输入差异

python 2: input 默认接收整形数据，str类型要用引号包起来，或用raw_input函数可以接收字符串 
python 3: input 函数接收，获得输入类型为字符型

代码举例
python2：

>>> input("请输入任意字符：")

请输入任意字符：as
报错

>>> input("请输入任意字符")

请输入任意字符：“as”

报错

>>> input("请输入任意字符")

请输入任意字符：'as'

'as'

>>> raw_input("请输入任意字符")

请输入任意字符：as

'as'

python3：

>>> input("请输入任意字符：")

请输入任意字符：ad

'ad'

>>> input("请输入任意字符：")

请输入任意字符：‘ad’

'‘ad’'

>>> raw_input("请输入任意字符：")
报错

#即raw_input 在python3中已废除
5，数据类型与运算符差异

整除
python3： /表示真除
python2：整数相除只能获取商值，浮点型数据相除才能获得真实数据
整形数据
python3：只有int
python2：区分int和long

代码举例
pyhton2:
>>> a=999999999999
>>> print(type(a))
<type 'int'>

>>> c=99999999999999999999999999999
>>> print(type(c))
<type 'long'>

pyhton3:
python3:   >>> a=999999
>>> print(type(a))
<class 'int'>

>>> c=99999999999999999999999999999999999999999999999
>>> print(type(c))
<class 'int'>

6,range和xrange的区别
代码举例
pyhton2:
>>> range(0,4)
[0, 1, 2, 3]

>>> list(xrange(1,4))
[1, 2, 3]

>>> xrange(0,4)
xrange(4)

pyhotn3:
>>> range(0,4)
range(0, 4)

>>> list(range(0,4))
[0, 1, 2, 3]

python3已废除了xrange

7,异常机制的区别
代码举例
python2
>>> try:
...    a = 1/0
... except Exception,e:
...    print e

python3
>>> try:
...    a = 1/0
... except Exception as e:
...    print(e)

8，字符编码的区别
pyhton2：默认编码是ascii码
只支持英文字母，数字，特殊字符，不支持中文含有中文需要做编码声明，用utf-8:                
  #-*-coding: utf-8-*-           #encoding=utf-8  
pyhton3：默认编码是utf-8

9，布尔类型的区别
python2 True、False 是两个变量 可以更改 
python3  True、False变成两个关键字 不能进行修改
代码举例
python2：
>>> True = 3
>>> print True
3

>>> False = 66
>>> print False
66

python3：
>>> True = 2
报错

>>> False = 4
报错

10，模块导入的区别
python2  默认是相对导入，自己创建模块时，必须要有__init__.py的文件
python3  无要求

11，字符串的区别
python2   unicode类型表示字符串序列，str类型表示字节序列
python3    str类型表示字符串序列，byte类型表示字节序列
 
'''

#8,python中哪些是可变数据类型，哪些是不可变数据类型，为什么
'''
Python中的数据类型总共分为：

Number（数字）、Str（字符串）、Tuple（元组）、List（列表）、Sets（集合）、Dictionary（字典）

其中不可变数据类型：
数字、字符串、元组

可变数据类型：
列表、集合、字典
'''
#9,统计字符串中每个单词出现的次数
def f9():

    from collections import Counter
    txt = 'If you could choose what kind of world to live in, whatkind of world would you choose'
    counts = Counter(txt.split())
    print(counts)
#f9()

#10、Python实现，给定一个字符串，找到字符串中第一个重复的字符
def f10():
    txt = 'If you could choose what kind of world to live in what kind of world would you choose'
    check = []
    for i in txt.split():
        if i in check:
            print("第一个重复字符为：", i)
            break
        else:
            check.append(i)
    if check:
        exit
    else:
        print("该字符串无重复字符")
#f10()

# 11、什么是pep 8
'''
PEP8规范
1 缩进。4个空格的缩进（编辑器都可以完成此功能），不使用Tap，更不能混合使用Tap和空格。

2 每行最大长度79，换行可以使用反斜杠，最好使用圆括号。换行点要在操作符的后边敲回车。

3 类和top-level函数定义之间空两行；类中的方法定义之间空一行；函数内逻辑无关段落之间空一行；其他地方尽量不要再空行。

4 模块导入的顺序：按标准、三方和自己编写顺序依次导入，之间空一行。

5 不要在一句import中多个库，比如import os, sys不推荐

6 避免不必要的空格

7 注释必须要有

8 函数命名要遵循规范

10 尽可能使用‘is’‘is not’取代‘==’，比如if x is not None 要优于if x。

11 使用基于类的异常，每个模块或包都有自己的异常类，此异常类继承自Exception。

12 异常中try的代码尽可能少。

'''

# 12、python里如何赋值、浅拷贝、深拷贝的区别

'''
10、Python实现，给定一个字符串，找到字符串中第一个重复的字符
11、什么是pep 8
12、python里如何赋值、浅拷贝、深拷贝的区别
赋值：在python中赋值语句总是建立对象的引用值，而不是复制对象。因此，python变量更像是指针，而不是数据存储区域
深拷贝，浅拷贝的区别:
'''
#13简述python的内存管理机制
'''
（1）垃圾回收（分代回收和标记清除）

1、当内存中有不再使用的部分时，垃圾收集器就会把他们清理掉。它会去检查那些引用计数为0的对象，然后清除其在内存的空间。
当然除了引用计数为0的会被清除，还有一种情况也会被垃圾收集器清掉：当两个对象相互引用时，他们本身其他的引用已经为0了。

2、垃圾回收机制还有一个循环垃圾回收器, 确保释放循环引用对象(a引用b, b引用a, 导致其引用计数永远不为0)。

（2）引用计数
python内部使用引用计数，来保持追踪内存中的对象，Python内部记录了对象有多少个引用，即引用计数，
当对象被创建时就创建了一个引用计数，当对象不再需要时，这个对象的引用计数为0时，它被垃圾回收。

（3）内存池和缓冲区
Python提供了对内存的垃圾收集机制，但是它将不用的内存放到内存池而不是返回给操作系统。
Python中所有小于256个字节的对象都使用pymalloc实现的分配器，而大的对象则使用系统的 malloc。
另外Python对象，如整数，浮点数和List，都有其独立的私有内存池，对象间不共享他们的内存池。
也就是说如果你分配又释放了大量的整数，用于缓存这些整数的内存就不能再分配给浮点数。


'''

#14、重复接收用户输入的一个字符串，如果是正整数, 就输出结果，否则一直输入
def f14():
    while True:
        try:
            n = int(input('请输入一个正整数：'))  # 接收一个字符串并转为整型
            if n > 0:  # 如果这个数为正数，输出，跳出循环
                print(n)
                break
            else:
                print('输入的不是一个正整数')  # 输入的不是正数，继续输入
        except Exception as e:
            print('输入的不是一个正整数')
f14()

#15、以左下三角的形式输出1~9乘法口诀
def f15():
    print('左下三角输出乘法口诀：')
    for i in range(1,10):
        for j in range(1, i + 1):
            print("%d*%d=%2d" % (i, j, i * j), end=" ")
        print("")
#f15()

#16、实现n的阶乘
def jc(n):
    if n < 0:
        return("负数不可以阶乘")
    elif n == 1 or n == 0:
        return 1
    else:
        return n * jc(n - 1)
#n=int(input("请输入一个数字："))
#print(f"{n}的阶乘为：",jc(n))

#17、给定一个列表如[1,2,3,4,5,6] ，指定任意一个数字如6 ，快速的计算出列表里哪两个数相加为6，若相加都不为6则输出提示。
def f17():
    arr = [1,2,3,4,5,6]
    s=6
    n = len(arr)
    res = []
    for i in range(n):
        for j in range(i + 1, n):
            if arr[i] + arr[j] == s:
                res.append((arr[i], arr[j]))
    print(res)
#f17()

#18、打印出所有100到999的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。
# 例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。
def f18():
    slist = []
    for a in range(100, 999):  # 定义一个100-999之间的数
        i = int(a % 10)  # 取出个位
        j = int(a / 100)  # 取出百位
        k = int((a - j * 100) / 10)  # 取出十位
        if i ** 3 + j ** 3 + k ** 3 == a:
            slist.append(a)
    print("100-999之间的水仙花数为：",slist)
#f18()

#19、用python实现冒泡排序

def f19():
    lis = input('请输入你要排序的数：')
    arr = [int(a) for a in lis.split()]
    if len(arr)<2:
        print(arr)
    else:
        for j in range(len(arr)-1):
            for i in range(len(arr)-1-j):
                if arr[i] > arr[i+1]:
                    temp = arr[i+1]
                    arr[i+1],arr[i] = arr[i],temp
            print(arr)
#f19()
#20、用python实现快速排序
'''
1,在数列之中，选择一个元素作为”基准”（mid），或者叫比较值。

2,数列中所有元素都和这个基准值进行比较，如果比基准值小就移到基准值的左边，如果比基准值大就移到基准值的右边

3,以基准值左右两边的子列作为新数列，不断重复第一步和第二步，直到所有子集只剩下一个元素为止。

'''
def f20(arr):
    if len(arr) < 2:
        return arr
    mid = arr[len(arr) // 2]  # 选取基准，随便选哪个都可以，选中间的便于理解
    left, right = [], []    # 定义基准值左右两个数列
    arr.remove(mid)    # 从原始数组中移除基准值
    for i in arr:
        if i >= mid:
            right.append(i)  # 大于基准值放右边
        else:
            left.append(i)   # 小于基准值放左边
    # 使用迭代进行比较
    return f20(left) + [mid] + f20(right) # 使用迭代进行比较
arr = [12,3,45,6,46,78,123]
#print(f20(arr))

